// 泛型
/**
 * 为什么会有泛型
 */
import React from 'react'
import { type } from 'os';
namespace a {
  function createArray<T>(length: number, value: T): Array<T> {
    let result: Array<T> = []
    for (let i = 0; i < length; i++) {
      result[i] = value;
    }
    return result;
  }
  let res = createArray<string>(4, 'x')
  console.log(res);
  function sum(...args2: any[]) {
    let args: IArguments = arguments;
    for (let i = 0; i < args.length; i++) {
      console.log(args[i]);
    }
  }
  sum(1, 2, 3, 4, 5)
  // let root: HTMLElement | null = document.getElementById('root')
  // let children: HTMLCollection = root!.children;
  // let childNodes: NodeListOf<ChildNode> = root!.childNodes;
  // 泛型类
  // =================接口泛型===============
  interface Calculate { // 这个接口是用来修饰这个函数的
    <T>(a: T, b: T): T
  }
  let add: Calculate = function <T>(a: T, b: T) {
    console.log('b:', b);
    return a
  }
  add<number>(1, 4)
  // 多个类型参数，如何在不增加中间变量的情况下，交换两个变量的值
  function swap<A, B>(temp: [A, B]): [B, A] {
    return [temp[1], temp[0]]
  }
  console.log(swap<number, string>([1, '3']));
  // 默认泛型类型
  function createArray2<T = number>(length: number, value: T): Array<T> {
    let result: Array<T> = [];
    for (let index = 0; index < length; index++) {
      result[index] = value
    }
    return result
  }
  let a = createArray2(3, 'a')
  console.log('a:', a);
  // ===============接口泛型=================
  // 泛型的约束
  // 在函数中使用泛型的时候，由于预先并不知道具体的类型，所以不能访问相应类型的方法
  interface LengthWise {
    length: number;
  }
  function logger<T extends LengthWise>(val: T) {
    console.log(val.length)
  }
  logger('磊超')
  // 描述一种对象
  interface Cart<T> {
    list: T[]
  }
  let cart: Cart<number> = {
    list: [1, 2, 3, 4, 5]
  }
  // 泛型类型别名
  // type Cart
  // type Cart
}